Constraint-Aware Model Merging

Since the beginning of computer science, raising the abstraction level of software systems has been a continuous process. One of the latest steps in this direction has led to the usage of modelling languages in software development processes. Software models are abstract representations of software systems which are used to tackle the complexity of present-day software by enabling developers to reason at a higher level of abstraction. In model-driven engineering (MDE), models are first-class entities of the software development process and undergo a complex evolution during their life-cycles. As a consequence, there is a growing need for techniques and tools to support model management activities such as version control. In optimistic version control, each developer has a local copy of a software artefact. These local copies are modified independently and in parallel and, from time to time, local modifications are merged together. The merge is performed using a three-way merging technique [6], which attempts to merge two versions of a software artefact relying on the common ancestor version from which both versions originated. This technique facilitates the detection of conflicts. Roughly speaking, conflicts may arise when the modifications are contradictory. They are resolved either manually or, when applicable, automatically. Mainstream version control systems, e.g. [1], target text-based artefacts. Hence, underlying techniques such as merging, conflict detection and conflict resolution are based on a per-line textual comparison. Since the structure of models is graph-based rather than text-based, these techniques are not suitable for MDE. To cope with this problem, a few prototype version control systems have been developed that target graph-based structures, e.g. [2]. However, a uniform formalisation of model merging, conflict detection and conflict resolution in MDE is still debated in the literature. Research has lead to a number of findings in this field [6]. The interested reader may consult [7, 3, 12, 11, 4] for different approaches to model merging, conflict detection and conflict resolution. Unfortunately, these techniques consider only model elements and their conformance to the constraints of the corresponding modelling language, e.g. wellformedness constraints. However, these techniques should also consider constraints added to model elements, e.g. multiplicity constraints. An interesting challenge is then to extend the current techniques by enabling version control of constraints. In this work, a formal approach to constraint-aware model merging is proposed; i.e. a model merging technique which enables the detection and possibly resolution of semantic conflicts on constraints. The proposed approach is based on the Diagram Predicate Framework (DPF) [9, 7, 10, 8] which provides a formalisation of (meta)modelling and model transformation based on graph theory and category theory. The word “model” has different meanings in different contexts. In software engineering, model denotes “an abstraction of a (real or language-based) system allowing predictions or inferences to be made” [5]. Models in software engineering are typically diagrammatic. The word “diagram” has also different meanings in different contexts. In software engineering, diagram denotes a structure which is based on graphs; i.e. a collection of nodes together with a collection of arrows between nodes. Since graph-based structures can be visualised in a natural way, “visual” and “diagrammatic” modelling are often treated as synonyms. In this work, visualisation and diagrammatic syntax are clearly distinguished. That is, the proposed approach focuses on precise syntax and semantics of diagrammatic models independent of their visualisation. In DPF, models are represented by (diagrammatic) specifications. A specification S = (S,C : Σ) consists of an underlying graph S together with a set of atomic constraints C [9, 8]. The graph